home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / rdflib / store / Sleepycat.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  15.7 KB  |  560 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from rdflib.store import Store
  5. from rdflib.URIRef import URIRef
  6. from bsddb import db
  7. from os import mkdir
  8. from os.path import exists, abspath
  9. from urllib import pathname2url
  10. from threading import Thread
  11. import logging
  12. _logger = logging.getLogger(__name__)
  13.  
  14. class Sleepycat(Store):
  15.     context_aware = True
  16.     formula_aware = True
  17.     
  18.     def __init__(self, configuration = None, identifier = None):
  19.         self._Sleepycat__open = False
  20.         self._Sleepycat__identifier = identifier
  21.         super(Sleepycat, self).__init__(configuration)
  22.         self.configuration = configuration
  23.         self._loads = self.node_pickler.loads
  24.         self._dumps = self.node_pickler.dumps
  25.  
  26.     
  27.     def __get_identifier(self):
  28.         return self._Sleepycat__identifier
  29.  
  30.     identifier = property(__get_identifier)
  31.     
  32.     def open(self, path, create = True):
  33.         homeDir = path
  34.         envsetflags = db.DB_CDB_ALLDB
  35.         envflags = db.DB_INIT_MPOOL | db.DB_INIT_CDB | db.DB_THREAD
  36.         if not exists(homeDir):
  37.             if create == True:
  38.                 mkdir(homeDir)
  39.                 self.create(path)
  40.             else:
  41.                 return -1
  42.         create == True
  43.         if self._Sleepycat__identifier is None:
  44.             self._Sleepycat__identifier = URIRef(pathname2url(abspath(homeDir)))
  45.         
  46.         self.db_env = db_env = db.DBEnv()
  47.         db_env.set_cachesize(0, 52428800)
  48.         db_env.set_flags(envsetflags, 1)
  49.         db_env.open(homeDir, envflags | db.DB_CREATE)
  50.         self._Sleepycat__open = True
  51.         dbname = None
  52.         dbtype = db.DB_BTREE
  53.         dbopenflags = db.DB_THREAD
  54.         dbmode = 432
  55.         dbsetflags = 0
  56.         self._Sleepycat__indicies = [
  57.             None] * 3
  58.         self._Sleepycat__indicies_info = [
  59.             None] * 3
  60.         for i in xrange(0, 3):
  61.             index_name = to_key_func(i)(('s', 'p', 'o'), 'c')
  62.             index = db.DB(db_env)
  63.             index.set_flags(dbsetflags)
  64.             index.open(index_name, dbname, dbtype, dbopenflags | db.DB_CREATE, dbmode)
  65.             self._Sleepycat__indicies[i] = index
  66.             self._Sleepycat__indicies_info[i] = (index, to_key_func(i), from_key_func(i))
  67.         
  68.         lookup = { }
  69.         for i in xrange(0, 8):
  70.             results = []
  71.             for start in xrange(0, 3):
  72.                 score = 1
  73.                 len = 0
  74.                 for j in xrange(start, start + 3):
  75.                     if i & 1 << j % 3:
  76.                         score = score << 1
  77.                         len += 1
  78.                         continue
  79.                 
  80.                 tie_break = 2 - start
  81.                 results.append(((score, tie_break), start, len))
  82.             
  83.             results.sort()
  84.             (score, start, len) = results[-1]
  85.             
  86.             def get_prefix_func(start, end):
  87.                 
  88.                 def get_prefix(triple, context):
  89.                     if context is None:
  90.                         yield ''
  91.                     else:
  92.                         yield context
  93.                     i = start
  94.                     while i < end:
  95.                         yield triple[i % 3]
  96.                         i += 1
  97.                     yield ''
  98.  
  99.                 return get_prefix
  100.  
  101.             lookup[i] = (self._Sleepycat__indicies[start], get_prefix_func(start, start + len), from_key_func(start), results_from_key_func(start, self._from_string))
  102.         
  103.         self._Sleepycat__lookup_dict = lookup
  104.         self._Sleepycat__contexts = db.DB(db_env)
  105.         self._Sleepycat__contexts.set_flags(dbsetflags)
  106.         self._Sleepycat__contexts.open('contexts', dbname, dbtype, dbopenflags | db.DB_CREATE, dbmode)
  107.         self._Sleepycat__namespace = db.DB(db_env)
  108.         self._Sleepycat__namespace.set_flags(dbsetflags)
  109.         self._Sleepycat__namespace.open('namespace', dbname, dbtype, dbopenflags | db.DB_CREATE, dbmode)
  110.         self._Sleepycat__prefix = db.DB(db_env)
  111.         self._Sleepycat__prefix.set_flags(dbsetflags)
  112.         self._Sleepycat__prefix.open('prefix', dbname, dbtype, dbopenflags | db.DB_CREATE, dbmode)
  113.         self._Sleepycat__k2i = db.DB(db_env)
  114.         self._Sleepycat__k2i.set_flags(dbsetflags)
  115.         self._Sleepycat__k2i.open('k2i', dbname, db.DB_HASH, dbopenflags | db.DB_CREATE, dbmode)
  116.         self._Sleepycat__i2k = db.DB(db_env)
  117.         self._Sleepycat__i2k.set_flags(dbsetflags)
  118.         self._Sleepycat__i2k.open('i2k', dbname, db.DB_RECNO, dbopenflags | db.DB_CREATE, dbmode)
  119.         self._Sleepycat__needs_sync = False
  120.         t = Thread(target = self._Sleepycat__sync_run)
  121.         t.setDaemon(True)
  122.         t.start()
  123.         self._Sleepycat__sync_thread = t
  124.         return 1
  125.  
  126.     
  127.     def __sync_run(self):
  128.         sleep = sleep
  129.         time = time
  130.         import time
  131.         
  132.         try:
  133.             (min_seconds, max_seconds) = (10, 300)
  134.             while self._Sleepycat__open:
  135.                 if self._Sleepycat__needs_sync:
  136.                     t0 = t1 = time()
  137.                     self._Sleepycat__needs_sync = False
  138.                     while self._Sleepycat__open:
  139.                         sleep(0.1)
  140.                         if self._Sleepycat__needs_sync:
  141.                             t1 = time()
  142.                             self._Sleepycat__needs_sync = False
  143.                         
  144.                         if time() - t1 > min_seconds or time() - t0 > max_seconds:
  145.                             self._Sleepycat__needs_sync = False
  146.                             _logger.debug('sync')
  147.                             self.sync()
  148.                             break
  149.                             continue
  150.                     continue
  151.                 sleep(1)
  152.         except Exception:
  153.             e = None
  154.             _logger.exception(e)
  155.  
  156.  
  157.     
  158.     def sync(self):
  159.         if self._Sleepycat__open:
  160.             for i in self._Sleepycat__indicies:
  161.                 i.sync()
  162.             
  163.             self._Sleepycat__contexts.sync()
  164.             self._Sleepycat__namespace.sync()
  165.             self._Sleepycat__prefix.sync()
  166.             self._Sleepycat__i2k.sync()
  167.             self._Sleepycat__k2i.sync()
  168.         
  169.  
  170.     
  171.     def close(self, commit_pending_transaction = False):
  172.         self._Sleepycat__open = False
  173.         self._Sleepycat__sync_thread.join()
  174.         for i in self._Sleepycat__indicies:
  175.             i.close()
  176.         
  177.         self._Sleepycat__contexts.close()
  178.         self._Sleepycat__namespace.close()
  179.         self._Sleepycat__prefix.close()
  180.         self._Sleepycat__i2k.close()
  181.         self._Sleepycat__k2i.close()
  182.         self.db_env.close()
  183.  
  184.     
  185.     def add(self, .1, context, quoted = False):
  186.         '''        Add a triple to the store of triples.
  187.         '''
  188.         (subject, predicate, object) = .1
  189.         if not self._Sleepycat__open:
  190.             raise AssertionError, 'The Store must be open.'
  191.         if not context != self:
  192.             raise AssertionError, 'Can not add triple directly to store'
  193.         Store.add(self, (subject, predicate, object), context, quoted)
  194.         _to_string = self._to_string
  195.         s = _to_string(subject)
  196.         p = _to_string(predicate)
  197.         o = _to_string(object)
  198.         c = _to_string(context)
  199.         (cspo, cpos, cosp) = self._Sleepycat__indicies
  200.         value = cspo.get('%s^%s^%s^%s^' % (c, s, p, o))
  201.         if value is None:
  202.             self._Sleepycat__contexts.put(c, '')
  203.             if not cspo.get('%s^%s^%s^%s^' % ('', s, p, o)):
  204.                 pass
  205.             contexts_value = ''
  206.             contexts = set(contexts_value.split('^'))
  207.             contexts.add(c)
  208.             contexts_value = '^'.join(contexts)
  209.             if not contexts_value != None:
  210.                 raise AssertionError
  211.             cspo.put('%s^%s^%s^%s^' % (c, s, p, o), '')
  212.             cpos.put('%s^%s^%s^%s^' % (c, p, o, s), '')
  213.             cosp.put('%s^%s^%s^%s^' % (c, o, s, p), '')
  214.             self._Sleepycat__needs_sync = True
  215.         
  216.  
  217.     
  218.     def __remove(self, .1, c, quoted = False):
  219.         (s, p, o) = .1
  220.         (cspo, cpos, cosp) = self._Sleepycat__indicies
  221.         if not cspo.get('^'.join(('', s, p, o, ''))):
  222.             pass
  223.         contexts_value = ''
  224.         contexts = set(contexts_value.split('^'))
  225.         contexts.discard(c)
  226.         contexts_value = '^'.join(contexts)
  227.         for i, _to_key, _from_key in self._Sleepycat__indicies_info:
  228.             i.delete(_to_key((s, p, o), c))
  229.         
  230.         if not quoted:
  231.             if contexts_value:
  232.                 for i, _to_key, _from_key in self._Sleepycat__indicies_info:
  233.                     i.put(_to_key((s, p, o), ''), contexts_value)
  234.                 
  235.             else:
  236.                 for i, _to_key, _from_key in self._Sleepycat__indicies_info:
  237.                     
  238.                     try:
  239.                         i.delete(_to_key((s, p, o), ''))
  240.                     continue
  241.                     except db.DBNotFoundError:
  242.                         e = None
  243.                         continue
  244.                     
  245.  
  246.                 
  247.         
  248.  
  249.     
  250.     def remove(self, .1, context):
  251.         (subject, predicate, object) = .1
  252.         if not self._Sleepycat__open:
  253.             raise AssertionError, 'The Store must be open.'
  254.         Store.remove(self, (subject, predicate, object), context)
  255.         _to_string = self._to_string
  256.         if context is not None:
  257.             if context == self:
  258.                 context = None
  259.             
  260.         
  261.         if subject is not None and predicate is not None and object is not None and context is not None:
  262.             s = _to_string(subject)
  263.             p = _to_string(predicate)
  264.             o = _to_string(object)
  265.             c = _to_string(context)
  266.             value = self._Sleepycat__indicies[0].get('%s^%s^%s^%s^' % (c, s, p, o))
  267.             if value is not None:
  268.                 self._Sleepycat__remove((s, p, o), c)
  269.                 self._Sleepycat__needs_sync = True
  270.             
  271.         else:
  272.             (cspo, cpos, cosp) = self._Sleepycat__indicies
  273.             (index, prefix, from_key, results_from_key) = self._Sleepycat__lookup((subject, predicate, object), context)
  274.             cursor = index.cursor()
  275.             
  276.             try:
  277.                 current = cursor.set_range(prefix)
  278.                 needs_sync = True
  279.             except db.DBNotFoundError:
  280.                 current = None
  281.                 needs_sync = False
  282.  
  283.             cursor.close()
  284.             while current:
  285.                 (key, value) = current
  286.                 cursor = index.cursor()
  287.                 
  288.                 try:
  289.                     cursor.set_range(key)
  290.                     current = cursor.next()
  291.                 except db.DBNotFoundError:
  292.                     current = None
  293.  
  294.                 cursor.close()
  295.                 if key.startswith(prefix):
  296.                     (c, s, p, o) = from_key(key)
  297.                     if context is None:
  298.                         if not index.get(key):
  299.                             pass
  300.                         contexts_value = ''
  301.                         contexts = set(contexts_value.split('^'))
  302.                         contexts.add('')
  303.                         for c in contexts:
  304.                             for i, _to_key, _ in self._Sleepycat__indicies_info:
  305.                                 i.delete(_to_key((s, p, o), c))
  306.                             
  307.                         
  308.                     else:
  309.                         self._Sleepycat__remove((s, p, o), c)
  310.                 context is None
  311.                 break
  312.             if context is not None:
  313.                 if subject is None and predicate is None and object is None:
  314.                     
  315.                     try:
  316.                         self._Sleepycat__contexts.delete(_to_string(context))
  317.                     except db.DBNotFoundError:
  318.                         e = None
  319.                     except:
  320.                         None<EXCEPTION MATCH>db.DBNotFoundError
  321.                     
  322.  
  323.                 None<EXCEPTION MATCH>db.DBNotFoundError
  324.             
  325.             self._Sleepycat__needs_sync = needs_sync
  326.  
  327.     
  328.     def triples(self, .1, context = None):
  329.         '''A generator over all the triples matching '''
  330.         (subject, predicate, object) = .1
  331.         if not self._Sleepycat__open:
  332.             raise AssertionError, 'The Store must be open.'
  333.         if context is not None:
  334.             if context == self:
  335.                 context = None
  336.             
  337.         
  338.         _from_string = self._from_string
  339.         (index, prefix, from_key, results_from_key) = self._Sleepycat__lookup((subject, predicate, object), context)
  340.         cursor = index.cursor()
  341.         
  342.         try:
  343.             current = cursor.set_range(prefix)
  344.         except db.DBNotFoundError:
  345.             current = None
  346.  
  347.         cursor.close()
  348.         while current:
  349.             (key, value) = current
  350.             cursor = index.cursor()
  351.             
  352.             try:
  353.                 cursor.set_range(key)
  354.                 current = cursor.next()
  355.             except db.DBNotFoundError:
  356.                 current = None
  357.  
  358.             cursor.close()
  359.             if key and key.startswith(prefix):
  360.                 contexts_value = index.get(key)
  361.                 yield results_from_key(key, subject, predicate, object, contexts_value)
  362.                 continue
  363.             break
  364.  
  365.     
  366.     def __len__(self, context = None):
  367.         if not self._Sleepycat__open:
  368.             raise AssertionError, 'The Store must be open.'
  369.         if context is not None:
  370.             if context == self:
  371.                 context = None
  372.             
  373.         
  374.         if context is None:
  375.             prefix = '^'
  376.         else:
  377.             prefix = '%s^' % self._to_string(context)
  378.         index = self._Sleepycat__indicies[0]
  379.         cursor = index.cursor()
  380.         current = cursor.set_range(prefix)
  381.         count = 0
  382.         while current:
  383.             (key, value) = current
  384.             if key.startswith(prefix):
  385.                 count += 1
  386.                 current = cursor.next()
  387.                 continue
  388.             break
  389.         cursor.close()
  390.         return count
  391.  
  392.     
  393.     def bind(self, prefix, namespace):
  394.         prefix = prefix.encode('utf-8')
  395.         namespace = namespace.encode('utf-8')
  396.         bound_prefix = self._Sleepycat__prefix.get(namespace)
  397.         if bound_prefix:
  398.             self._Sleepycat__namespace.delete(bound_prefix)
  399.         
  400.         self._Sleepycat__prefix[namespace] = prefix
  401.         self._Sleepycat__namespace[prefix] = namespace
  402.  
  403.     
  404.     def namespace(self, prefix):
  405.         prefix = prefix.encode('utf-8')
  406.         return self._Sleepycat__namespace.get(prefix, None)
  407.  
  408.     
  409.     def prefix(self, namespace):
  410.         namespace = namespace.encode('utf-8')
  411.         return self._Sleepycat__prefix.get(namespace, None)
  412.  
  413.     
  414.     def namespaces(self):
  415.         cursor = self._Sleepycat__namespace.cursor()
  416.         results = []
  417.         current = cursor.first()
  418.         while current:
  419.             (prefix, namespace) = current
  420.             results.append((prefix, namespace))
  421.             current = cursor.next()
  422.         cursor.close()
  423.         for prefix, namespace in results:
  424.             yield (prefix, URIRef(namespace))
  425.         
  426.  
  427.     
  428.     def contexts(self, triple = None):
  429.         _from_string = self._from_string
  430.         _to_string = self._to_string
  431.         if triple:
  432.             (s, p, o) = triple
  433.             s = _to_string(s)
  434.             p = _to_string(p)
  435.             o = _to_string(o)
  436.             contexts = self._Sleepycat__indicies[0].get('%s^%s^%s^%s^' % ('', s, p, o))
  437.             if contexts:
  438.                 for c in contexts.split('^'):
  439.                     if c:
  440.                         yield _from_string(c)
  441.                         continue
  442.                 
  443.             
  444.         else:
  445.             index = self._Sleepycat__contexts
  446.             cursor = index.cursor()
  447.             current = cursor.first()
  448.             cursor.close()
  449.             while current:
  450.                 (key, value) = current
  451.                 context = _from_string(key)
  452.                 yield context
  453.                 cursor = index.cursor()
  454.                 
  455.                 try:
  456.                     cursor.set_range(key)
  457.                     current = cursor.next()
  458.                 except db.DBNotFoundError:
  459.                     current = None
  460.  
  461.                 cursor.close()
  462.  
  463.     
  464.     def _from_string(self, i):
  465.         k = self._Sleepycat__i2k.get(int(i))
  466.         return self._loads(k)
  467.  
  468.     
  469.     def _to_string(self, term):
  470.         k = self._dumps(term)
  471.         i = self._Sleepycat__k2i.get(k)
  472.         if i is None:
  473.             i = '%s' % self._Sleepycat__i2k.append(k)
  474.             self._Sleepycat__k2i.put(k, i)
  475.         
  476.         return i
  477.  
  478.     
  479.     def __lookup(self, .1, context):
  480.         (subject, predicate, object) = .1
  481.         _to_string = self._to_string
  482.         if context is not None:
  483.             context = _to_string(context)
  484.         
  485.         i = 0
  486.         if subject is not None:
  487.             i += 1
  488.             subject = _to_string(subject)
  489.         
  490.         if predicate is not None:
  491.             i += 2
  492.             predicate = _to_string(predicate)
  493.         
  494.         if object is not None:
  495.             i += 4
  496.             object = _to_string(object)
  497.         
  498.         (index, prefix_func, from_key, results_from_key) = self._Sleepycat__lookup_dict[i]
  499.         prefix = '^'.join(prefix_func((subject, predicate, object), context))
  500.         return (index, prefix, from_key, results_from_key)
  501.  
  502.  
  503.  
  504. def to_key_func(i):
  505.     
  506.     def to_key(triple, context):
  507.         '''Takes a string; returns key'''
  508.         return '^'.join((context, triple[i % 3], triple[(i + 1) % 3], triple[(i + 2) % 3], ''))
  509.  
  510.     return to_key
  511.  
  512.  
  513. def from_key_func(i):
  514.     
  515.     def from_key(key):
  516.         '''Takes a key; returns string'''
  517.         parts = key.split('^')
  518.         return (parts[0], parts[((3 - i) + 0) % 3 + 1], parts[((3 - i) + 1) % 3 + 1], parts[((3 - i) + 2) % 3 + 1])
  519.  
  520.     return from_key
  521.  
  522.  
  523. def results_from_key_func(i, from_string):
  524.     
  525.     def from_key(key, subject, predicate, object, contexts_value):
  526.         '''Takes a key and subject, predicate, object; returns tuple for yield'''
  527.         parts = key.split('^')
  528.         if subject is None:
  529.             s = from_string(parts[((3 - i) + 0) % 3 + 1])
  530.         else:
  531.             s = subject
  532.         if predicate is None:
  533.             p = from_string(parts[((3 - i) + 1) % 3 + 1])
  534.         else:
  535.             p = predicate
  536.         if object is None:
  537.             o = from_string(parts[((3 - i) + 2) % 3 + 1])
  538.         else:
  539.             o = object
  540.         return (((s, p, o),), (lambda .0: for c in .0:
  541. if c:
  542. from_string(c)continue)(contexts_value.split('^')))
  543.  
  544.     return from_key
  545.  
  546.  
  547. def readable_index(i):
  548.     (s, p, o) = '???'
  549.     if i & 1:
  550.         s = 's'
  551.     
  552.     if i & 2:
  553.         p = 'p'
  554.     
  555.     if i & 4:
  556.         o = 'o'
  557.     
  558.     return '%s,%s,%s' % (s, p, o)
  559.  
  560.